home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-01 / dkbuts.zip / DUMP2RGB.C < prev    next >
C/C++ Source or Header  |  1991-05-16  |  6KB  |  253 lines
  1. #include <stdio.h>
  2.  
  3. /* #define IBM TRUE */
  4.  
  5. #define PARAMS(x) x
  6.  
  7. struct Image_Line
  8.    {
  9.    unsigned char *red, *green, *blue;
  10.    };
  11.  
  12. struct Image_Struct
  13.    {
  14.    int iwidth, iheight;
  15.    IMAGE_LINE *rgb_lines;
  16.    };
  17.  
  18. typedef struct Image_Struct IMAGE;
  19.  
  20. IMAGE Raw_Image;
  21.  
  22. FILE *fp, *palette_file, *output_palette_file;
  23. FILE *fred, *fgrn, *fblu;
  24. char input_filename[100], master_filename[100], output_filename[100];
  25. int image_width, image_height;
  26.  
  27. #ifdef IBM
  28. #define REDNAME "%s.r8"
  29. #define GRNNAME "%s.g8"
  30. #define BLUNAME "%s.b8"
  31. #define DEFAULT_WIDTH  320
  32. #define DEFAULT_HEIGHT 200
  33. #else
  34. #define REDNAME "%s.red"
  35. #define GRNNAME "%s.grn"
  36. #define BLUNAME "%s.blu"
  37. #define DEFAULT_WIDTH  320
  38. #define DEFAULT_HEIGHT 400
  39. #endif
  40.  
  41. int read_raw_byte PARAMS((FILE *f));
  42. int read_raw_word PARAMS((FILE *f));
  43. void read_raw_image PARAMS((IMAGE *Image));
  44. void get_parameters PARAMS((int argc, char **argv));
  45. void OpenRGB PARAMS((void));
  46. void SaveRGB PARAMS((int red, int grn, int blu));
  47.  
  48. void main (argc, argv) 
  49.    int argc;
  50.    char **argv;
  51.    {
  52.    unsigned int x, y, index;
  53.  
  54.    if (argc < 2)
  55.      {
  56.      printf ("\nUsage:  DumpToRGB [-wxxx -hxxx] <filename>\n   .dis extension is assumed for <filename>\n   default image size: %d x %d", DEFAULT_WIDTH, DEFAULT_HEIGHT);
  57.      exit(0);
  58.      }
  59.  
  60.    fp = NULL;
  61.  
  62.    get_parameters(argc, argv);
  63.  
  64.    printf ("Reading raw file\n");
  65.    read_raw_image (&Raw_Image);
  66.  
  67.    printf ("Converting...\n");
  68.  
  69.    OpenRGB();
  70.    for (y = 0 ; y < Raw_Image.height ; y++) {
  71.       for (x = 0 ; x < Raw_Image.width ; x++) {
  72.          index = y*Raw_Image.width + x;
  73.          SaveRGB((int)Raw_Image.red[index],(int)Raw_Image.green[index],(int)Raw_Image.blue[index]);
  74.          }
  75.       for (; x < image_width ; x++)
  76.     SaveRGB(0, 0, 0);
  77.       }
  78.    for (; y < image_height ; y++)
  79.       for (; x < image_width; x++)
  80.     SaveRGB(0, 0, 0);
  81.    fclose(fred);
  82.    fclose(fgrn);
  83.    fclose(fblu);
  84.    }
  85.  
  86. void get_parameters (argc, argv)
  87.    int argc;
  88.    char **argv;
  89.    {
  90.    int i, filename_number;
  91.  
  92.    image_height = DEFAULT_HEIGHT;
  93.    image_width = DEFAULT_WIDTH;
  94.  
  95.    filename_number = 0;
  96.    for (i = 1 ; i < argc ; i++) {
  97.  
  98.       if (argv[i][0] == '-')
  99.      switch (argv[i][1]) {
  100.         case 'w': sscanf(&argv[i][2], "%d", &image_height);
  101.               break;
  102.         case 'h': sscanf(&argv[i][2], "%d", &image_height);
  103.               break;
  104.         default : printf("Unknown option %s - proceeding...\n");
  105.         }
  106.       else
  107.          switch (filename_number) {
  108.             case 0: strcpy (master_filename, argv[i]);
  109.             sprintf (input_filename, "%s.dis", master_filename);
  110.             filename_number++;
  111.                     break;
  112.  
  113.             default: printf ("Too many filenames in commandline\n");
  114.                      exit(1);
  115.             }
  116.       }
  117.    }
  118.  
  119.  
  120. int read_raw_byte(f)
  121.    FILE *f;
  122.    {
  123.    int c;
  124.    if ((c = getc(f)) == EOF)
  125.       return (-1);
  126.    return (c);
  127.    }
  128.  
  129. int read_raw_word(f)
  130.    FILE *f;
  131.    {
  132.    int byte1, byte2;
  133.  
  134.    byte1 = read_raw_byte(f);
  135.    if (byte1 == -1)
  136.       return(-1);
  137.  
  138.    byte2 = read_raw_byte(f);
  139.    if (byte2 == -1)
  140.       return(-1);
  141.  
  142.    return (byte1 + byte2*256);
  143.    }
  144.  
  145. void OpenRGB()
  146. {
  147.    char nmbuff[200];
  148.  
  149.    sprintf( nmbuff, REDNAME, master_filename );
  150.    if ((fred = fopen(nmbuff, "wb")) == NULL) {
  151.       printf ("Cannot open red output file for %s\n", master_filename);
  152.       exit(1);
  153.       }
  154.  
  155.    sprintf( nmbuff, GRNNAME, master_filename );
  156.    if ((fgrn = fopen(nmbuff, "wb")) == NULL) {
  157.       printf ("Cannot open green output file for %s\n", master_filename);
  158.       exit(1);
  159.       }
  160.  
  161.    sprintf( nmbuff, BLUNAME, master_filename );
  162.    if ((fblu = fopen(nmbuff, "wb")) == NULL) {
  163.       printf ("Cannot open blue output file for %s\n", master_filename);
  164.       exit(1);
  165.       }
  166. }
  167.  
  168. void SaveRGB(red, grn, blu)
  169. int red, grn, blu;
  170. {
  171.    fputc( red, fred );
  172.    fputc( grn, fgrn );
  173.    fputc( blu, fblu );
  174. }
  175.  
  176. void read_raw_image(Image)
  177.    IMAGE *Image;
  178.    {
  179.    FILE *f;
  180.    unsigned int i, index, pixels;
  181.    int byte, row;
  182.  
  183.    if ((f = fopen(input_filename, "rb")) == NULL) {
  184.       printf ("Cannot open raw file %s\n", input_filename);
  185.       exit(1);
  186.       }
  187.  
  188.    Image->width = read_raw_word(f);
  189.    if (Image->width == -1) {
  190.       printf ("Cannot read size in dump file\n");
  191.       exit(1);
  192.       }
  193.  
  194.    Image->height = read_raw_word(f);
  195.    if (Image->height == -1) {
  196.       printf ("Cannot read size in dump file: %s\n", input_filename);
  197.       exit(1);
  198.       }
  199.  
  200.    pixels = Image->width * Image->height;
  201.  
  202.    if (((Image->red = (unsigned char *) malloc(pixels))==NULL) ||
  203.        ((Image->green = (unsigned char *) malloc(pixels))==NULL) ||
  204.        ((Image->blue = (unsigned char *) malloc(pixels))==NULL)) {
  205.       printf ("Cannot allocate memory for picture: %s\n", input_filename);
  206.       exit(1);
  207.       }
  208.  
  209.    for (i = 0 ; i < pixels ; i++) {
  210.       Image->red[i] = 0;
  211.       Image->green[i] = 0;
  212.       Image->blue[i] = 0;
  213.       }
  214.  
  215.    row = read_raw_word(f);
  216.    while (row != -1) {
  217.       for (i = 0 ; i < Image->width ; i++) {
  218.          index = row*Image->width + i;
  219.  
  220.          byte = read_raw_byte(f);
  221.          if (byte == -1) {
  222.             printf ("Unexpected end of file in raw image: %s\n", input_filename);
  223.             exit(1);
  224.             }
  225.          Image->red[index] = byte;
  226.          }
  227.  
  228.       for (i = 0 ; i < Image->width ; i++) {
  229.          index = row*Image->width + i;
  230.  
  231.          byte = read_raw_byte(f);
  232.          if (byte == -1) {
  233.             printf ("Unexpected end of file in raw image: %s\n", input_filename);
  234.             exit(1);
  235.             }
  236.          Image->green[index] = byte;
  237.          }
  238.  
  239.       for (i = 0 ; i < Image->width ; i++) {
  240.          index = row*Image->width + i;
  241.  
  242.          byte = read_raw_byte(f);
  243.          if (byte == -1) {
  244.             printf ("Unexpected end of file in raw image: %s\n", input_filename);
  245.             exit(1);
  246.             }
  247.          Image->blue[index] = byte;
  248.          }
  249.       row = read_raw_word(f);
  250.       }
  251.    fclose (f);
  252.    }
  253.